/**
 * JZ UnoCSS - CSS更新器
 * 负责将生成的CSS写入文件系统
 * @version 1.1.0
 * @author jz
 */

/**
 * 更新CSS文件的主函数
 * @param {string} cssContent - CSS内容
 * @param {Object} config - 配置对象
 * @returns {boolean} 是否成功更新
 */
export function updateMainCSS(cssContent, config = {}) {
    // 验证CSS内容
    if (!cssContent || typeof cssContent !== 'string' || cssContent.trim() === '') {
        console.warn('[JZ UnoCSS] CSS内容为空，跳过写入');
        return false;
    }
    
    try {
        // 尝试获取Node.js模块
        const fs = require('fs');
        const path = require('path');
        
        // 确定输出路径
        let outputPath = config.cssOutputPath || 'uni_modules/jz-unocss-uvue/main.css';
        
        // 如果路径不是绝对路径，尝试解析相对于项目根目录的路径
        if (!path.isAbsolute(outputPath)) {
            // 检测项目根目录
            let projectRoot = process.cwd();
            
            // 如果在uni_modules中，向上查找项目根目录
            if (projectRoot.includes('uni_modules')) {
                const parts = projectRoot.split(path.sep);
                const uniModulesIndex = parts.findIndex(part => part === 'uni_modules');
                if (uniModulesIndex > 0) {
                    projectRoot = parts.slice(0, uniModulesIndex).join(path.sep);
                }
            }
            
            outputPath = path.resolve(projectRoot, outputPath);
        }
        
        // 确保目录存在
        const dir = path.dirname(outputPath);
        if (!fs.existsSync(dir)) {
            fs.mkdirSync(dir, { recursive: true });
        }
        
        // 写入文件
        fs.writeFileSync(outputPath, cssContent, 'utf-8');
        
        // 验证写入结果
        try {
            const verifyContent = fs.readFileSync(outputPath, 'utf-8');
            if (verifyContent.length !== cssContent.length) {
                console.error(`[JZ UnoCSS] 文件写入验证失败: 预期${cssContent.length}字符，实际${verifyContent.length}字符`);
            }
        } catch (verifyError) {
            console.error('[JZ UnoCSS] 文件写入验证失败:', verifyError.message);
        }
        
        return true;
    } catch (error) {
        console.error('[JZ UnoCSS] CSS文件写入失败:', error);
        console.error('[JZ UnoCSS] 错误详情:', {
            cssLength: cssContent.length,
            outputPath: config.cssOutputPath,
            error: error.message
        });
        return false;
    }
}

/**
 * 生成基础CSS的函数
 * @param {string[]} classNames - 类名数组
 * @param {Object} options - 选项
 * @returns {string} CSS内容
 */
export async function generateBasicCSS(classNames, options = {}) {
    const cssRules = [];
    const processedClasses = new Set();
    const isProduction = options.mode === 'production';
    
    // 基础样式映射
    const basicStyles = {
        // Flexbox
        'flex': { 'display': 'flex' },
        'flex-col': { 'display': 'flex', 'flex-direction': 'column' },
        'flex-row': { 'display': 'flex', 'flex-direction': 'row' },
        'items-center': { 'align-items': 'center' },
        'items-start': { 'align-items': 'flex-start' },
        'items-end': { 'align-items': 'flex-end' },
        'justify-center': { 'justify-content': 'center' },
        'justify-start': { 'justify-content': 'flex-start' },
        'justify-end': { 'justify-content': 'flex-end' },
        'justify-between': { 'justify-content': 'space-between' },
        'justify-around': { 'justify-content': 'space-around' },
        
        // Display
        'block': { 'display': 'block' },
        'inline': { 'display': 'inline' },
        'inline-block': { 'display': 'inline-block' },
        'hidden': { 'display': 'none' },
        
        // Positioning
        'relative': { 'position': 'relative' },
        'absolute': { 'position': 'absolute' },
        'fixed': { 'position': 'fixed' },
        
        // Size
        'w-full': { 'width': '100%' },
        'h-full': { 'height': '100%' },
        'w-auto': { 'width': 'auto' },
        'h-auto': { 'height': 'auto' },
        
        // Text
        'text-center': { 'text-align': 'center' },
        'text-left': { 'text-align': 'left' },
        'text-right': { 'text-align': 'right' },
        
        // Colors
        'text-white': { 'color': '#ffffff' },
        'text-black': { 'color': '#000000' },
        'bg-white': { 'background-color': '#ffffff' },
        'bg-black': { 'background-color': '#000000' },
        'bg-transparent': { 'background-color': 'transparent' },
        
        // Spacing
        'p-0': { 'padding': '0' },
        'p-1': { 'padding': '0.25rem' },
        'p-2': { 'padding': '0.5rem' },
        'p-4': { 'padding': '1rem' },
        'm-0': { 'margin': '0' },
        'm-1': { 'margin': '0.25rem' },
        'm-2': { 'margin': '0.5rem' },
        'm-4': { 'margin': '1rem' },
        'm-auto': { 'margin': 'auto' },
        
        // Border
        'border': { 'border': '1px solid #e5e7eb' },
        'border-0': { 'border': 'none' },
        'rounded': { 'border-radius': '0.25rem' },
        'rounded-lg': { 'border-radius': '0.5rem' },
        'rounded-full': { 'border-radius': '9999px' },
        
        // Overflow
        'overflow-hidden': { 'overflow': 'hidden' },
        'overflow-auto': { 'overflow': 'auto' },
        'overflow-scroll': { 'overflow': 'scroll' }
    };
    
    let successCount = 0;
    
    // 尝试使用generateCSS函数
    let generateCSS;
    try {
        const generatorModule = await import('../core/generator.js');
        generateCSS = generatorModule.generateCSS;
    } catch (error) {
        console.warn('[JZ UnoCSS] generateCSS函数不可用，使用minimal CSS');
        generateCSS = null;
    }
    
    for (const className of classNames) {
        if (processedClasses.has(className)) {
            continue;
        }
        
        try {
            let styles = null;
            
            // 首先尝试使用generateCSS函数
            if (generateCSS) {
                try {
                    styles = generateCSS(className, options);
                } catch (genError) {
                    // 如果generateCSS失败，继续使用基础样式
                }
            }
            
            // 如果generateCSS不可用或失败，使用基础样式映射
            if (!styles || (typeof styles === 'object' && Object.keys(styles).length === 0)) {
                styles = basicStyles[className];
            }
            
            if (styles && typeof styles === 'object' && Object.keys(styles).length > 0) {
                // 编码类名
                const encodedClassName = encodeClassNameForUvue(className);
                
                if (isProduction) {
                    // 生产模式：压缩格式
                    const cssProps = Object.entries(styles)
                        .map(([prop, value]) => `${prop}:${value}`)
                        .join(';');
                    cssRules.push(`.${encodedClassName}{${cssProps}}`);
                } else {
                    // 开发模式：格式化
                    const cssProps = Object.entries(styles)
                        .map(([prop, value]) => `  ${prop}: ${value};`)
                        .join('\n');
                    cssRules.push(`.${encodedClassName} {\n${cssProps}\n}`);
                }
                
                successCount++;
                processedClasses.add(className);
            } else if (typeof styles === 'string') {
                // 直接是CSS字符串（如条件编译CSS）
                cssRules.push(styles);
                successCount++;
                processedClasses.add(className);
            }
        } catch (error) {
            console.warn(`[JZ UnoCSS] 生成基础CSS时出错 "${className}":`, error.message);
        }
    }
    
    // 添加CSS头部
    const header = isProduction 
        ? `/* JZ UnoCSS ${successCount} rules */\n`
        : `/* JZ UnoCSS - 基础CSS生成器 */
/* 生成时间: ${new Date().toLocaleString()} */
/* 生成规则: ${successCount} 条 */

`;
    
    const cssContent = header + (isProduction ? cssRules.join('') : cssRules.join('\n\n'));
    
    return cssContent;
}

/**
 * 简单的类名编码函数
 * @param {string} className - 类名
 * @returns {string} 编码后的类名
 */
function encodeClassNameForUvue(className) {
    if (!className || typeof className !== 'string') {
        return className;
    }
    
    // 简单的编码规则
    return className
        .replace(/\[/g, 'L')
        .replace(/\]/g, 'R')
        .replace(/%/g, 'P')
        .replace(/\./g, 'D')
        .replace(/#/g, 'S')
        .replace(/\(/g, 'O')
        .replace(/\)/g, 'C')
        .replace(/,/g, 'M')
        .replace(/\//g, 'F');
}

/**
 * 生成最小CSS的函数
 * @param {string[]} classNames - 类名数组
 * @param {Object} options - 选项
 * @returns {string} CSS内容
 */
export function generateMinimalCSS(classNames, options = {}) {
    const cssRules = [];
    
    // 最基本的CSS规则
    const minimalRules = {
        'flex': 'display:flex',
        'flex-col': 'display:flex;flex-direction:column',
        'flex-row': 'display:flex;flex-direction:row',
        'items-center': 'align-items:center',
        'justify-center': 'justify-content:center',
        'w-full': 'width:100%',
        'h-full': 'height:100%',
        'text-center': 'text-align:center',
        'p-4': 'padding:1rem',
        'm-4': 'margin:1rem',
        'bg-white': 'background-color:#ffffff',
        'text-black': 'color:#000000'
    };
    
    for (const className of classNames) {
        const encodedClassName = encodeClassNameForUvue(className);
        if (minimalRules[className]) {
            cssRules.push(`.${encodedClassName}{${minimalRules[className]}}`);
        } else {
            // 对于未知类名，尝试简单解析
            try {
                if (className.startsWith('w-') && className.includes('[') && className.includes(']')) {
                    const widthMatch = className.match(/w-\[([^\]]+)\]/);
                    if (widthMatch) {
                        cssRules.push(`.${encodedClassName}{width:${widthMatch[1]}}`);
                    }
                } else if (className.startsWith('h-') && className.includes('[') && className.includes(']')) {
                    const heightMatch = className.match(/h-\[([^\]]+)\]/);
                    if (heightMatch) {
                        cssRules.push(`.${encodedClassName}{height:${heightMatch[1]}}`);
                    }
                } else if (className.startsWith('text-') && className.includes('[') && className.includes(']')) {
                    const textMatch = className.match(/text-\[([^\]]+)\]/);
                    if (textMatch) {
                        const value = textMatch[1];
                        if (value.includes('px') || value.includes('rem') || value.includes('em')) {
                            cssRules.push(`.${encodedClassName}{font-size:${value}}`);
                        } else if (value.startsWith('#') || value.startsWith('rgb')) {
                            cssRules.push(`.${encodedClassName}{color:${value}}`);
                        }
                    }
                }
            } catch (error) {
                console.warn(`[JZ UnoCSS] 为 "${className}" 生成备用CSS时出错:`, error.message);
            }
        }
    }
    
    return `/* JZ UnoCSS Minimal */\n${cssRules.join('')}`;
}

/**
 * 通用的CSS更新函数
 * @param {string} cssContent - CSS内容
 * @param {Object} config - 配置对象
 * @returns {boolean} 是否成功更新
 */
export function updateCSSFile(cssContent, config = {}) {
    // 验证参数
    if (!cssContent) {
        if (typeof cssContent !== 'string') {
            console.error('[JZ UnoCSS] ❌ CSS内容无效:', typeof cssContent);
            return false;
        }
        
        if (cssContent.trim() === '') {
            console.warn('[JZ UnoCSS] ⚠️ CSS内容为空，跳过写入，保持现有文件');
            return false; // 不要生成基础CSS，直接返回false
        }
    }
    
    try {
        // 检查Node.js环境
        let fs, path;
        try {
            fs = require('fs');
            path = require('path');
        } catch (e) {
            return false;
        }
        
        // 确定输出路径
        let outputPath = config.cssOutputPath || 'uni_modules/jz-unocss-uvue/main.css';
        
        // 检测项目根目录
        let projectRoot = process.cwd();
        
        // 如果在HBuilderX环境中，尝试找到正确的项目根目录
        if (projectRoot.includes('HBuilderX') || projectRoot.includes('plugins')) {
            // 在HBuilderX环境中搜索项目根目录
            const possiblePaths = [
                process.env.UNI_INPUT_DIR,
                process.env.UNI_OUTPUT_DIR,
                path.resolve(projectRoot, '../../../'),
                path.resolve(projectRoot, '../../../../'),
                path.resolve(projectRoot, '../../../../../'),
            ].filter(Boolean);
            
            for (const testPath of possiblePaths) {
                try {
                    if (fs.existsSync(testPath)) {
                        const hasManifest = fs.existsSync(path.join(testPath, 'manifest.json'));
                        const hasPages = fs.existsSync(path.join(testPath, 'pages.json'));
                        const hasUniModules = fs.existsSync(path.join(testPath, 'uni_modules'));
                        
                        if (hasManifest || hasPages || hasUniModules) {
                            projectRoot = testPath;
                            break;
                        }
                    }
                } catch (error) {
                    continue;
                }
            }
        }
        
        // 如果在uni_modules中，向上查找项目根目录
        if (projectRoot.includes('uni_modules')) {
            const parts = projectRoot.split(path.sep);
            const uniModulesIndex = parts.findIndex(part => part === 'uni_modules');
            if (uniModulesIndex > 0) {
                projectRoot = parts.slice(0, uniModulesIndex).join(path.sep);
            }
        }
        
        // 解析最终输出路径
        if (!path.isAbsolute(outputPath)) {
            outputPath = path.resolve(projectRoot, outputPath);
        }
        
        // 确保目录存在
        const dir = path.dirname(outputPath);
        if (!fs.existsSync(dir)) {
            fs.mkdirSync(dir, { recursive: true });
        }
        
        // 写入文件
        fs.writeFileSync(outputPath, cssContent, 'utf-8');
        
        // 验证写入结果
        try {
            const verifyContent = fs.readFileSync(outputPath, 'utf-8');
            if (verifyContent.length === cssContent.length) {
                // 写入成功
            } else {
                console.warn(`[JZ UnoCSS] ⚠️ 文件大小不匹配: 预期 ${cssContent.length}，实际 ${verifyContent.length}`);
                
                // 尝试重新写入
                try {
                    console.error('[JZ UnoCSS] ❌ 文件写入异常，重新写入...');
                    fs.writeFileSync(outputPath, cssContent, 'utf-8');
                    
                    // 再次验证
                    const retryVerifyContent = fs.readFileSync(outputPath, 'utf-8');
                    if (retryVerifyContent.length === cssContent.length) {
                        // 重新写入成功
                    } else {
                        console.error('[JZ UnoCSS] ❌ 重新写入失败，文件可能存在权限问题');
                        return false;
                    }
                } catch (retryError) {
                    console.error('[JZ UnoCSS] ❌ 重新写入时出错:', retryError.message);
                    return false;
                }
            }
        } catch (verifyError) {
            // 验证失败，但写入可能成功了
        }
        
        return true;
    } catch (error) {
        console.error('[JZ UnoCSS] ❌ CSS更新失败:', error);
        console.error('[JZ UnoCSS] 错误详情:', {
            cssLength: cssContent ? cssContent.length : 0,
            outputPath: config.cssOutputPath,
            error: error.message
        });
        
        // 不要写入fallback CSS，保持现有文件不变
        console.error('[JZ UnoCSS] ❌ CSS写入失败，保持现有文件不变，不覆盖已有内容');
        
        return false;
    }
}

/**
 * 生成备用CSS
 * @param {string[]} classNames - 类名数组
 * @param {Object} options - 选项
 * @returns {string} CSS内容
 */
export function generateFallbackCSS(classNames, options = {}) {
    // 生成最基本的CSS作为备用
    const fallbackCSS = `/* JZ UnoCSS - Fallback CSS */
.flex { display: flex; }
.flex-col { display: flex; flex-direction: column; }
.flex-row { display: flex; flex-direction: row; }
.items-center { align-items: center; }
.justify-center { justify-content: center; }
.w-full { width: 100%; }
.h-full { height: 100%; }
.text-center { text-align: center; }
.p-4 { padding: 1rem; }
.m-4 { margin: 1rem; }
.bg-white { background-color: #ffffff; }
.text-black { color: #000000; }
`;
    
    return fallbackCSS;
}

// 函数已在定义时导出，无需重复导出 